import org.junit.Test;

import java.util.Arrays;

/**
 * 程序只有一个入口：main方法 程序入口
 * 理解：类中只有一个主方法
 *
 * 类中多个类似主方法：单元测试 Junit1.4【外置jar包】
 *                                 jar别人写好的类，直接使用
 * 单元测试：专门测试功能模块
 * 1.编写注解   @Test编写单元测试
 * 2.编写方法    修饰符  返回值 方法名（）{}
 * 3.运行：点中方法名，右键Run As-->Junit Test
 *
 *
 *
 */

public class 基础语法 {
    /**
     * float  单精度  不常用   4个字节  取小数点后6位有效数
     * 写法：float  标识符=字面量F/f;
     */
    @Test
    public void basic() {
        float pi = 3.1415926535F;
        System.out.println(pi);//3.1415927
        int a = 128 + 256;//00000000 00000000 00000001 10000000
        byte b = (byte) a;//砍掉前24位  剩余部分10000000
        System.out.println(b);//-128
        // int _123F=1;
        //  int 123F=1;
        //  int if =1;

        String name = "耶耶";
        int age = 18;
        System.out.println(name + age);
    }

    /**
     * 数组 Array   引用类型     对象，通过new创建
     * 数组相当于一堆相同的“数据”集合
     * 单元测试1：testArray   创建数组方式以及初始化
     */
    @Test
    public void testArray() {
        //创建一个arr空数组，长度为4
        int[] arr = new int[4];//动态初始化：指定空间，并且按照空间分元素
        int[] arr1 = {1, 2, 3};//静态初始化：直接给定值
        int arr2[] = new int[4];//动态初始化：指定空间，并且按照空间分元素
        int[] arr3 = new int[]{1, 2, 3};//动态初始化：指定空间，并且按照空间分元素
        //从arr1静态初始化数组获取2元素  数组名【下标：0开始】
        System.out.println(arr1[1]);//输出2元素值
        // 从arr1静态初始化数组获取  长度
        System.out.println(arr1.length);//输出3
        //在arr1中获取下标为4的值   会输出？  数组下标越界异常
        //   System.out.println(arr1[4]);//ArrayIndexOutOfBoundsException
        //空间长度没有超出范围，数据类型：基础数据类型
        //                     int 默认值：0
        //                     float 默认值：0.0
        //                     char 默认值：特殊符号
        //                     boolean 默认值：false

        int arr4[] = new int[4];//动态初始化：指定空间，并且按照空间分元素
        System.out.println(arr4[1]);
        float arr5[] = new float[4];
        System.out.println(arr5[1]);
        char arr6[] = new char[4];
        System.out.println(arr6[1]);
        boolean arr7[] = new boolean[4];
        System.out.println(arr7[1]);
    }

    /**
     * 数组遍历【3种迭代方式】
     * 1.普通for循环   jdk1.5之前使用
     * 2.增强for循环   jdk1.5之后使用  推荐
     * 3.Arrays工具类  推荐
     */
    @Test
    public void testIterate() {
        int[] arr = {1, 2, 3, 4};//静态数组
        //     for (int i=0;i<arr.length;i++){//获取数组的下标
        //        System.out.println(arr[i]);
        //    }
        //  遍历数据类型      引用名：数组名
        //  for(int i:arr){//直接打印元素值
        //      System.out.println(i);
        //  }
        //工具类  toString方法  打印所有数组元素
        System.out.println(Arrays.toString(arr));
    }

    /**
     * 数组扩容
     * Java数组对象大小是固定的，数组对象不可以扩展的
     * 使用数组扩容方式变通
     * Arrays.copyof() 方法创建数组副本
     */
    @Test
    public void testCopy() {
        char[] arr = {'唐', '山'};//定义数组，长度固定：2个
        char[] temp = Arrays.copyOf(arr, 4);
        //副本  复制给  不可改变的数组
        char[] tarr = temp;
        System.out.println(tarr);    //唐  山  /u0000  /u0000
        tarr[2] = '工';
        tarr[3] = '业';
        System.out.println(tarr);
    }

    /**
     * 拓展：数组输出，根据数据类型不同，输出效果不同【看】
     * 数组语法：
     * 数据类型[]  数组名=new 数据类型[]
     * 数据类型:基础数据类型+引用类型
     * 创建数据根据数据类型：明确是什么类型
     */
    @Test
    public void testLook() {
        //字符数组————输出方式
        char[] china = {'中', '国'};
        System.out.println(china);   //输出：中国
        // Javaoop面向对象知识点 数组输出方法提供了重载功能，字符数组，优化为字符串
        //常规数组输出效果 Arrays工具类 toString方法：打印数组
        System.out.println(Arrays.toString(china));//输出  [中, 国]

        //数值数组
        int[] i = {1, 2};
        System.out.println(i); // [数组  I类型  @地址值  [I@3d82c5f3
        //查看数组实际效果
        System.out.println(Arrays.toString(i));

    }

    /**
     * 数组经典案例：
     * int[] arr={3,6,4,1};
     * 数组元素排序：升序，降序
     * 面试题：上述数组按照升序方式排序
     * 解题思路三种方案：选择排序、冒泡排序、插入排序
     * 冒泡排序：双层for循环使用，比较相邻的元素，将元素组小的值放到前面
     */

    @Test
    public void bubbleSort(){
        int[] arr={3,6,4,1};  //0  1  2    //静态数组
        //  for  外层循环【轮】+for  内层循环【次】
        //考虑：每一轮需要比较几次
        for(int i=0;i<arr.length-1;i++){//外层控制   3轮  可以拿到结果
            for(int j=0;j<arr.length-1-i;j++){//内层控制  3次递减
                //交换：第一次值>第二次值  成立  交换
                if(arr[j]>arr[j+1]){//第一值：元素数arr[j]       第二值：元素数arr[j+1]
                    //交换：第三方数组变量  交换数组名temp
                    int temp=arr[j];  //①第一个值交给第三方数组变量
                    arr[j]=arr[j+1];//②第二个值交给第一个值
                    arr[j+1]=temp; //③第三方数组变量交给第二个值
                }
            }
        }

        for(int i=0;i<arr.length-1;i++){    //外层for：控制比较轮
            for(int j=0;j<arr.length-1-i;j++){  //内层for：两两比较
                //交换    升序：从小到大
                if(arr[j]>arr[j+1]) {
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1]=temp;
                }
            }
        }
        System.out.println(Arrays.toString(arr));
    }
    @Test
    public void sort(){
        int[] arr={3,6,4,1};
        //工具类提供sort()排序方法
        Arrays.sort(arr);    //默认：升序
        System.out.println(Arrays.toString(arr));
    }
}






















